package com.ruoyi;//给定一个字符串 s ，请你找出其中不含有重复字符的 最长 子串 的长度。
//
//
//
// 示例 1:
//
//
//输入: s = "abcabcbb"
//输出: 3
//解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
//
//
// 示例 2:
//
//
//输入: s = "bbbbb"
//输出: 1
//解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
//
//
// 示例 3:
//
//
//输入: s = "pwwkew"
//输出: 3
//解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
//     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
//
//
//
//
// 提示：
//
//
// 0 <= s.length <= 5 * 10⁴
// s 由英文字母、数字、符号和空格组成
//
//
// Related Topics 哈希表 字符串 滑动窗口 👍 10547 👎 0


import org.junit.jupiter.api.Test;

import java.util.*;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public static void main(String[] args) {
//        Integer count =  extracted();
//        System.out.println(count);
    }
    @Test
    public void testextracted(){
        Integer extracted = extracted2();
//        Integer extracted = lengthOfLongestSubstring("ababcdadfr");
        System.out.println(extracted);
    }

    /**
     * 左右两个指针相减
     */
    public void testextracted3(){
        String  s = "ababcdadfrexyzggg";
        s="bb";
        for (int right = 0; right < s.length(); right++) {
            for(int left = right; left < s.length(); left++) {
                if(s.charAt(left) == s.charAt(right)) {

                }
            }
        }
    }

    public Integer extracted2() {
        String  s = "ababcdadfrexyzggg";
        Set<Character> set = new HashSet<>();
        // 右指针
        int ans = 0;

        // 左指针
        for (int i = 0; i < s.length(); i++) {
            set.clear();
            set.add(s.charAt(i));
            for(int j = i+1;j<s.length();j++){
                if(!set.contains(s.charAt(j))){
                    set.add(s.charAt(j));
                }else {
                    break;
                }
            }
            ans = Math.max(ans,set.size());
        }
        return ans;
    }


    public Integer extracted() {
        String  s = "ababcdadfr";
        char[] charArray = s.toCharArray();
        Map<String,Integer> resultMap= new HashMap<>();
        int count = 0;
        if(charArray.length <= 1){
            count = charArray.length;
            return count;
        }

        List<Character> result ;
        for(int i=0; i<charArray.length; i++){
            result = new ArrayList<>();
            result.add(charArray[i]);
            for(int j=i+1; j<charArray.length; j++){

                if(!result.contains(charArray[j])){
                    result.add(charArray[j]);
                } else{

                    resultMap.put(result.toString(),result.size());
                    if(result.size() > count){
                        count = result.size();
                    }
                    break;
                }
                if(j == charArray.length-1){
                    if(result.size() > count){
                        count = result.size();
                    }
                    resultMap.put(result.toString(),result.size());
                    break;
                }
            }
        }
        resultMap.forEach( (k,v)->{});
        return count;
    }


    public int lengthOfLongestSubstring(String s) {
        // 哈希集合，记录每个字符是否出现过
        Set<Character> occ = new HashSet<Character>();
        int n = s.length();
        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
        int rk = -1, ans = 0;
        for (int i = 0; i < n; ++i) {
            if (i != 0) {
                // 左指针向右移动一格，移除一个字符
                occ.remove(s.charAt(i - 1));
            }
            while (rk + 1 < n && !occ.contains(s.charAt(rk + 1))) {
                // 不断地移动右指针
                occ.add(s.charAt(rk + 1));
                ++rk;
            }
            // 第 i 到 rk 个字符是一个极长的无重复字符子串
            ans = Math.max(ans, rk - i + 1);
        }
        return ans;
    }

}
//leetcode submit region end(Prohibit modification and deletion)






